#ifndef RUTF8Encoding_H
#define RUTF8Encoding_H

#include <System/Text/Encoding.h>

namespace Riccsson
{
	namespace System
	{
		namespace Text
		{
			// Summary:
			// Represents a UTF-8 encoding of Unicode characters.
			class UTF8Encoding
				: public Encoding
			{

				//
				// Summary:
				//     When overridden in a derived class, gets a name for the current encoding
				//     that can be used with mail agent body tags.
				//
				// Returns:
				//     A name for the current System.Text.Encoding that can be used with mail agent
				//     body tags.-or- An empty string (""), if the current System.Text.Encoding
				//     cannot be used.
				public: override PROP3_GET(string, BodyName)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets the code page identifier of the
				//     current System.Text.Encoding.
				//
				// Returns:
				//     The code page identifier of the current System.Text.Encoding.
				public: override PROP3_GET(int, CodePage)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets the human-readable description of
				//     the current encoding.
				//
				// Returns:
				//     The human-readable description of the current System.Text.Encoding.
				public: override PROP3_GET(string, EncodingName)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a name for the current encoding
				//     that can be used with mail agent header tags.
				//
				// Returns:
				//     A name for the current System.Text.Encoding to use with mail agent header
				//     tags.-or- An empty string (""), if the current System.Text.Encoding cannot
				//     be used.
				public: override PROP3_GET(string, HeaderName)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by browser clients for displaying content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by browser clients for
				//     displaying content; otherwise, false.
				public: override PROP3_GET(bool, IsBrowserDisplay)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by browser clients for saving content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by browser clients for
				//     saving content; otherwise, false.
				public: override PROP3_GET(bool, IsBrowserSave)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by mail and news clients for displaying content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by mail and news clients
				//     for displaying content; otherwise, false.
				public: override PROP3_GET(bool, IsMailNewsDisplay)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding can be used by mail and news clients for saving content.
				//
				// Returns:
				//     true if the current System.Text.Encoding can be used by mail and news clients
				//     for saving content; otherwise, false.
				public: override PROP3_GET(bool, IsMailNewsSave)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding uses single-byte code points.
				//
				// Returns:
				//     true if the current System.Text.Encoding uses single-byte code points; otherwise,
				//     false.
				//[ComVisible(false)]
				public: override PROP3_GET(bool, IsSingleByte)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets the name registered with the Internet
				//     Assigned Numbers Authority (IANA) for the current encoding.
				//
				// Returns:
				//     The IANA name for the current System.Text.Encoding.
				public: override PROP3_GET(string, WebName)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, gets the Windows operating system code
				//     page that most closely corresponds to the current encoding.
				//
				// Returns:
				//     The Windows operating system code page that most closely corresponds to the
				//     current System.Text.Encoding.
				public: override PROP3_GET(int, WindowsCodePage)
				{
					throw;
				}

				// Summary:
				//     When overridden in a derived class, creates a shallow copy of the current
				//     System.Text.Encoding object.
				//
				// Returns:
				//     A copy of the current System.Text.Encoding object.
				//[ComVisible(false)]
				public: override GC_PTR<Object> Clone()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding all the characters in the specified character array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding all the characters in the specified
				//     character array.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: override int GetByteCount(Riccsson::System::Array<char>* chars)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding the characters in the specified string.
				//
				// Parameters:
				//   s:
				//     The string containing the set of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: override int GetByteCount(string* s)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding a set of characters starting at the specified character pointer.
				//
				// Parameters:
				//   chars:
				//     A pointer to the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     count is less than zero.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: override int GetByteCount(Riccsson::System::Array<char>* chars, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of bytes produced
				//     by encoding a set of characters from the specified character array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   index:
				//     The index of the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     The number of bytes produced by encoding the specified characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in chars.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: int GetByteCount(Riccsson::System::Array<char>* chars, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes all the characters in the specified
				//     character array into a sequence of bytes.
				//
				// Parameters:
				//   chars:
				//     The character array containing the characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::Array<byte>> GetBytes(const Riccsson::System::Array<char>* chars)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes all the characters in the specified
				//     string into a sequence of bytes.
				//
				// Parameters:
				//   s:
				//     The string containing the characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::Array<byte>> GetBytes(const string* s)
				{
					if (s == null)
					{
						throw System::ArgumentNullException();
					}

					int length(s->Length);

					GC_PTR<Riccsson::System::Array<byte>> output(new Riccsson::System::Array<byte>(length));

					const char* str(s->c_str());
					for (int i = 0; i < length; i++)
					{
						output->Insert(i, (byte)str[i]);
					}

					return output;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified character array into a sequence of bytes.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   index:
				//     The index of the first character to encode.
				//
				//   count:
				//     The number of characters to encode.
				//
				// Returns:
				//     A byte array containing the results of encoding the specified set of characters.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in chars.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
				public: override GC_PTR<Riccsson::System::Array<byte>> GetBytes(Riccsson::System::Array<char>* chars, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters starting
				//     at the specified character pointer into a sequence of bytes that are stored
				//     starting at the specified byte pointer.
				//
				// Parameters:
				//   chars:
				//     A pointer to the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     A pointer to the location at which to start writing the resulting sequence
				//     of bytes.
				//
				//   byteCount:
				//     The maximum number of bytes to write.
				//
				// Returns:
				//     The actual number of bytes written at the location indicated by the bytes
				//     parameter.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charCount or byteCount is less than zero.
				//
				//   System.ArgumentException:
				//     byteCount is less than the resulting number of bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: override int GetBytes(Riccsson::System::Array<char>* chars, int charCount, Riccsson::System::Array<byte>* bytes, int byteCount)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified character array into the specified byte array.
				//
				// Parameters:
				//   chars:
				//     The character array containing the set of characters to encode.
				//
				//   charIndex:
				//     The index of the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     The byte array to contain the resulting sequence of bytes.
				//
				//   byteIndex:
				//     The index at which to start writing the resulting sequence of bytes.
				//
				// Returns:
				//     The actual number of bytes written into bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     chars is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charIndex or charCount or byteIndex is less than zero.-or- charIndex and
				//     charCount do not denote a valid range in chars.-or- byteIndex is not a valid
				//     index in bytes.
				//
				//   System.ArgumentException:
				//     bytes does not have enough capacity from byteIndex to the end of the array
				//     to accommodate the resulting bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: int GetBytes(Riccsson::System::Array<char>* chars, int charIndex, int charCount, Riccsson::System::Array<byte>* bytes, int byteIndex)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, encodes a set of characters from the
				//     specified string into the specified byte array.
				//
				// Parameters:
				//   s:
				//     The string containing the set of characters to encode.
				//
				//   charIndex:
				//     The index of the first character to encode.
				//
				//   charCount:
				//     The number of characters to encode.
				//
				//   bytes:
				//     The byte array to contain the resulting sequence of bytes.
				//
				//   byteIndex:
				//     The index at which to start writing the resulting sequence of bytes.
				//
				// Returns:
				//     The actual number of bytes written into bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     s is null.-or- bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     charIndex or charCount or byteIndex is less than zero.-or- charIndex and
				//     charCount do not denote a valid range in chars.-or- byteIndex is not a valid
				//     index in bytes.
				//
				//   System.ArgumentException:
				//     bytes does not have enough capacity from byteIndex to the end of the array
				//     to accommodate the resulting bytes.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: override int GetBytes(string* s, int charIndex, int charCount, Riccsson::System::Array<byte>* bytes, int byteIndex)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding all the bytes in the specified byte array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: override int GetCharCount(Riccsson::System::Array<byte>* bytes)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding a sequence of bytes starting at the specified byte pointer.
				//
				// Parameters:
				//   bytes:
				//     A pointer to the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     count is less than zero.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: override int GetCharCount(Riccsson::System::Array<byte>* bytes, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, calculates the number of characters produced
				//     by decoding a sequence of bytes from the specified byte array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The number of characters produced by decoding the specified sequence of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: int GetCharCount(Riccsson::System::Array<byte>* bytes, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes all the bytes in the specified
				//     byte array into a set of characters.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     A character array containing the results of decoding the specified sequence
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::Array<char>> GetChars(Riccsson::System::Array<byte>* bytes)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into a set of characters.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     A character array containing the results of decoding the specified sequence
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::Array<char>> GetChars(Riccsson::System::Array<byte>* bytes, int index, int count)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes starting
				//     at the specified byte pointer into a set of characters that are stored starting
				//     at the specified character pointer.
				//
				// Parameters:
				//   bytes:
				//     A pointer to the first byte to decode.
				//
				//   byteCount:
				//     The number of bytes to decode.
				//
				//   chars:
				//     A pointer to the location at which to start writing the resulting set of
				//     characters.
				//
				//   charCount:
				//     The maximum number of characters to write.
				//
				// Returns:
				//     The actual number of characters written at the location indicated by the
				//     chars parameter.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.-or- chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     byteCount or charCount is less than zero.
				//
				//   System.ArgumentException:
				//     charCount is less than the resulting number of characters.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				//[CLSCompliant(false)]
				//[ComVisible(false)]
				//[SecurityCritical]
				public: override int GetChars(Riccsson::System::Array<byte>* bytes, int byteCount, Riccsson::System::Array<char>* chars, int charCount)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into the specified character array.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   byteIndex:
				//     The index of the first byte to decode.
				//
				//   byteCount:
				//     The number of bytes to decode.
				//
				//   chars:
				//     The character array to contain the resulting set of characters.
				//
				//   charIndex:
				//     The index at which to start writing the resulting set of characters.
				//
				// Returns:
				//     The actual number of characters written into chars.
				//
				// Exceptions:
				//   System.ArgumentNullException:
				//     bytes is null.-or- chars is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     byteIndex or byteCount or charIndex is less than zero.-or- byteindex and
				//     byteCount do not denote a valid range in bytes.-or- charIndex is not a valid
				//     index in chars.
				//
				//   System.ArgumentException:
				//     chars does not have enough capacity from charIndex to the end of the array
				//     to accommodate the resulting characters.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: int GetChars(Riccsson::System::Array<byte>* bytes, int byteIndex, int byteCount, Riccsson::System::Array<char>* chars, int charIndex)
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, obtains a decoder that converts an encoded
				//     sequence of bytes into a sequence of characters.
				//
				// Returns:
				//     A System.Text.Decoder that converts an encoded sequence of bytes into a sequence
				//     of characters.
				public: override GC_PTR<Decoder> GetDecoder()
				{
					throw;
				}

				//
				// Summary:
				//     When overridden in a derived class, obtains an encoder that converts a sequence
				//     of Unicode characters into an encoded sequence of bytes.
				//
				// Returns:
				//     A System.Text.Encoder that converts a sequence of Unicode characters into
				//     an encoded sequence of bytes.
				public: override GC_PTR<Encoder> GetEncoder()
				{
					throw;
				}


				//
				// Summary:
				//     When overridden in a derived class, calculates the maximum number of bytes
				//     produced by encoding the specified number of characters.
				//
				// Parameters:
				//   charCount:
				//     The number of characters to encode.
				//
				// Returns:
				//     The maximum number of bytes produced by encoding the specified number of
				//     characters.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     charCount is less than zero.
				//
				//   System.Text.EncoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.EncoderFallback is set to System.Text.EncoderExceptionFallback.
				public: int GetMaxByteCount(int charCount)
				{
					throw;
				}


				//
				// Summary:
				//     When overridden in a derived class, calculates the maximum number of characters
				//     produced by decoding the specified number of bytes.
				//
				// Parameters:
				//   byteCount:
				//     The number of bytes to decode.
				//
				// Returns:
				//     The maximum number of characters produced by decoding the specified number
				//     of bytes.
				//
				// Exceptions:
				//   System.ArgumentOutOfRangeException:
				//     byteCount is less than zero.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: int GetMaxCharCount(int byteCount)
				{
					throw;
				}


				//
				// Summary:
				//     When overridden in a derived class, returns a sequence of bytes that specifies
				//     the encoding used.
				//
				// Returns:
				//     A byte array containing a sequence of bytes that specifies the encoding used.-or-
				//     A byte array of length zero, if a preamble is not required.
				public: override GC_PTR<Riccsson::System::Array<byte>> GetPreamble()
				{
					throw;
				}


				//
				// Summary:
				//     When overridden in a derived class, decodes all the bytes in the specified
				//     byte array into a string.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				// Returns:
				//     A string that contains the results of decoding the specified sequence of
				//     bytes.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The byte array contains invalid Unicode code points.
				//
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::string> GetString(Riccsson::System::Array<byte>* bytes)
				{
					return GC_PTR<Riccsson::System::string>( new string( bytes->get(), 0, bytes->Length ) );
				}


				//
				// Summary:
				//     When overridden in a derived class, decodes a sequence of bytes from the
				//     specified byte array into a string.
				//
				// Parameters:
				//   bytes:
				//     The byte array containing the sequence of bytes to decode.
				//
				//   index:
				//     The index of the first byte to decode.
				//
				//   count:
				//     The number of bytes to decode.
				//
				// Returns:
				//     A string that contains the results of decoding the specified sequence of
				//     bytes.
				//
				// Exceptions:
				//   System.ArgumentException:
				//     The byte array contains invalid Unicode code points.
				//
				//   System.ArgumentNullException:
				//     bytes is null.
				//
				//   System.ArgumentOutOfRangeException:
				//     index or count is less than zero.-or- index and count do not denote a valid
				//     range in bytes.
				//
				//   System.Text.DecoderFallbackException:
				//     A fallback occurred (see Character Encoding in the .NET Framework for complete
				//     explanation)-and-System.Text.Encoding.DecoderFallback is set to System.Text.DecoderExceptionFallback.
				public: override GC_PTR<Riccsson::System::string> GetString(Riccsson::System::Array<byte>* bytes, int index, int count)
				{
					GC_PTR<string> output( new string( bytes->get(), index, count ) );
					return output;
				}


				//
				// Summary:
				//     When overridden in a derived class, gets a value indicating whether the current
				//     encoding is always normalized, using the specified normalization form.
				//
				// Parameters:
				//   form:
				//     One of the System.Text.NormalizationForm values.
				//
				// Returns:
				//     true if the current System.Text.Encoding object is always normalized using
				//     the specified System.Text.NormalizationForm value; otherwise, false. The
				//     default is false.
				//[ComVisible(false)]
				public: override bool IsAlwaysNormalized(NormalizationForm* form)
				{
					throw;
				}

			};
		}
	}
}
#endif //EXTENSIONS_H